home *** CD-ROM | disk | FTP | other *** search
/ Aminet 3 / Aminet 3 - July 1994.iso / Aminet / misc / emu / jk_net.lha / amiga.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-13  |  4.7 KB  |  291 lines
  1.             /*   jk-net v0.5 copyright by infinity 1993,94   */
  2.  
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6.  
  7. #include <exec/types.h>
  8. #include <exec/memory.h>
  9. #include <exec/lists.h>
  10. #include <exec/nodes.h>
  11.  
  12. #include <libraries/dos.h>
  13. #include <libraries/dosextens.h>
  14.  
  15. #include <proto/dos.h>
  16. #include <proto/exec.h>
  17.  
  18. #define LOAD_code 0x01
  19. #define SAVE_code 0x02
  20. #define DIR_code 0x03
  21. #define QUIT_code 0x04
  22. #define CRAP_code 0xFF
  23.  
  24. void open_par(void);
  25. void close_par(void);
  26. int check_code(void);
  27. void load(void);
  28. void save(void);
  29. void dir(void);
  30. int copy_dir(char *,char *,int);
  31. void quit(void);
  32.  
  33. ULONG par_read_id;
  34. ULONG par_write_id;
  35.  
  36. void open_par()
  37. {
  38.     if ((par_read_id = Open("PAR:",MODE_OLDFILE)) == NULL)
  39.         {
  40.             printf("Can't open PAR: for read\n");
  41.             exit(0);
  42.         }
  43.  
  44.     if ((par_write_id = Open("PAR:",MODE_NEWFILE)) == NULL)
  45.         {
  46.             printf("Can't open PAR: for write\n");
  47.             if (par_read_id) Close(par_read_id);
  48.             exit(0);
  49.         }
  50. }
  51.  
  52. void close_par()
  53. {
  54.     if (par_read_id) Close(par_read_id);
  55.     if (par_write_id) Close(par_write_id);
  56. }
  57.  
  58. int check_code(void)
  59. {
  60.     UBYTE code=NULL;
  61.  
  62.     Read(par_read_id,&code,sizeof(code));
  63.  
  64.     switch(code)
  65.         {
  66.             case LOAD_code:
  67.                 load();
  68.                 return(FALSE);
  69.             case SAVE_code:
  70.                 save();
  71.                 return(FALSE);
  72.             case DIR_code:
  73.                 dir();
  74.                 return(FALSE);
  75.             case QUIT_code:
  76.                 quit();
  77.                 return(TRUE);
  78.             case CRAP_code:
  79.                 break;
  80.             default:
  81.                 printf("Illegal code from C64\n");
  82.         }
  83.     return(FALSE);
  84. }
  85.  
  86. void load()
  87. {
  88.     int i;
  89.     ULONG file_read_id;
  90.     ULONG lenght;
  91.     UWORD wlenght;
  92.     char name[32];
  93.     char name_64[17];
  94.     UBYTE *buffer;
  95.     UBYTE *buffer2;
  96.     UWORD nolla=NULL;
  97.  
  98.     strcpy(name,"C64_HD:");
  99.  
  100.     printf("Load code from C64\n");
  101.     Read(par_read_id,&name_64,16);
  102.  
  103.     i=0;
  104.     name_64[16]=' ';
  105.     while(name_64[++i] != ' ');
  106.     name_64[i]=NULL;
  107.  
  108.     i=0;
  109.     while(name_64[i])
  110.         name[i+7]=name_64[i++];
  111.     name[i+7]=NULL;
  112.  
  113.     printf("name: %s\n",name);
  114.  
  115.     if ((file_read_id = Open(name,MODE_OLDFILE)) == NULL)
  116.         {
  117.             printf("Can't open %s for read\n",name);
  118.             Write(par_write_id,&nolla,2);
  119.             return;
  120.         }
  121.  
  122.     if    ((buffer = AllocMem(2+65536,MEMF_PUBLIC)) == NULL)
  123.         {
  124.             printf("Can't allocate memory\n");
  125.             Write(par_write_id,&nolla,2);
  126.             return;
  127.         }
  128.  
  129.     if    ((buffer2 = AllocMem(4+65536,MEMF_PUBLIC)) == NULL)
  130.         {
  131.             printf("Can't allocate memory\n");
  132.             Write(par_write_id,&nolla,2);
  133.             return;
  134.         }
  135.  
  136.     lenght=Read(file_read_id,buffer,2+65536);
  137.     wlenght=(UWORD)(lenght-2);
  138.     printf("lenght: %d\n",wlenght);
  139.  
  140.     buffer2[0]=(UBYTE)(wlenght%256);
  141.     buffer2[1]=(UBYTE)(wlenght/256);
  142.  
  143.     i=0;
  144.     while(i!=2+lenght)
  145.         buffer2[i+2]=buffer[i++];
  146.  
  147.     Write(par_write_id,buffer2,2+lenght);
  148.  
  149.     Close(file_read_id);
  150.  
  151.     FreeMem(buffer,2+65536);
  152.     FreeMem(buffer2,4+65536);
  153. }
  154.  
  155. void save()
  156. {
  157.     int i;
  158.     ULONG file_write_id;
  159.     ULONG lenght;
  160.     UWORD wlenght;
  161.     char name[32];
  162.     char name_64[17];
  163.     UBYTE *buffer;
  164.  
  165.     strcpy(name,"C64_HD:");
  166.  
  167.     printf("Save code from C64\n");
  168.     Read(par_read_id,&name_64,16);
  169.  
  170.     i=0;
  171.     name_64[16]=' ';
  172.     while(name_64[++i] != ' ');
  173.     name_64[i]=NULL;
  174.  
  175.     i=0;
  176.     while(name_64[i])
  177.         name[i+7]=name_64[i++];
  178.     name[i+7]=NULL;
  179.  
  180.     printf("name: %s\n",name);
  181.  
  182.     if ((file_write_id = Open(name,MODE_NEWFILE)) == NULL)
  183.         {
  184.             printf("Can't open %s for write\n",name);
  185.             return;
  186.         }
  187.  
  188.     Read(par_read_id,&wlenght,2);
  189.     lenght=(ULONG)wlenght;
  190.     printf("lenght: %d\n",lenght);
  191.  
  192.     if ((buffer = AllocMem(2+lenght,MEMF_PUBLIC)) == NULL)
  193.         {
  194.             printf("Can't allocate memory\n");
  195.             return;
  196.         }
  197.  
  198.     Read(par_read_id,buffer,2+lenght);
  199.     Write(file_write_id,buffer,2+lenght);
  200.  
  201.     Close(file_write_id);
  202.  
  203.     FreeMem(buffer,2+lenght);
  204. }
  205.  
  206. void dir()
  207. {
  208.     struct FileInfoBlock fib;
  209.     char dir[65535];
  210.     char text[40];
  211.     ULONG lenght = 0;
  212.     ULONG lock = NULL;
  213.     int point = 0;
  214.     int i;
  215.  
  216.     strcpy(text,"0 \x12\"AMIGA           \" ID 2A\x92\xd\0");
  217.     point=copy_dir(text,dir,point);
  218.  
  219.     printf("Dir code from C64\n");
  220.  
  221.     if ((lock = Lock("C64_HD:\0",ACCESS_READ)) == NULL)
  222.         {
  223.             printf("Can't find C64_HD:\n");
  224.             return;
  225.         }
  226.  
  227.     if (Examine(lock,&fib)==NULL)
  228.         {
  229.             printf("Can't examine C64_HD:\n");
  230.             if (lock) UnLock(lock);
  231.             return;
  232.         }
  233.  
  234.     if (fib.fib_DirEntryType < 0)
  235.         {
  236.             printf("Not a dircetory\n");
  237.             if (lock) UnLock(lock);
  238.             return;
  239.         }
  240.  
  241.     while (ExNext(lock,&fib))
  242.         {
  243.             sprintf(text,"%-5d\"%-16s  PRG\xd\0",fib.fib_Size/254+1,fib.fib_FileName);
  244.  
  245.             i=6;
  246.             while(text[++i]!=' ');
  247.  
  248.             text[i]='"';
  249.  
  250.             point=copy_dir(text,dir,point);
  251.  
  252.             lenght += fib.fib_Size;
  253.         }
  254.  
  255.     if (lock) UnLock(lock);
  256.  
  257.     sprintf(text,"%d BLOCKS USED.\xd\0",lenght/254);
  258.     point=copy_dir(text,dir,point);
  259.  
  260.     dir[point]=(char)NULL;
  261.  
  262.     Write(par_write_id,&dir,point+2);
  263. }
  264.  
  265. int copy_dir(char *text,char *dir,int i)
  266. {
  267.     int j=0;
  268.  
  269.     while(dir[i++]=text[j++]);
  270.     return(i-1);
  271. }
  272.  
  273. void quit()
  274. {
  275.     printf("Quit code from C64\n");
  276. }
  277.  
  278. main()
  279. {
  280.     int stop=FALSE;
  281.  
  282.     open_par();
  283.  
  284.     while(!stop)
  285.         (stop=check_code());
  286.  
  287.     close_par();
  288.  
  289.     return(0);
  290. }
  291.